/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package ru.ibrae.mchs.radiation.entities.controllers;

import ru.ibrae.mchs.radiation.entities.DicIst;
import ru.ibrae.mchs.radiation.entities.controllers.exceptions.NonexistentEntityException;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import ru.ibrae.mchs.radiation.entities.Result;
import java.util.HashSet;
import java.util.Set;
import ru.ibrae.mchs.radiation.entities.CrossZon;

/**
 *
 * @author murr
 */
public class DicIstJpaController {

    public DicIstJpaController() {
        emf = Persistence.createEntityManagerFactory("DesktopApplication4PU");
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(DicIst dicIst) {
        if (dicIst.getResultSet() == null) {
            dicIst.setResultSet(new HashSet<Result>());
        }
        if (dicIst.getCrossZonSet() == null) {
            dicIst.setCrossZonSet(new HashSet<CrossZon>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Set<Result> attachedResultSet = new HashSet<Result>();
            for (Result resultSetResultToAttach : dicIst.getResultSet()) {
                resultSetResultToAttach = em.getReference(resultSetResultToAttach.getClass(), resultSetResultToAttach.getIdRezult());
                attachedResultSet.add(resultSetResultToAttach);
            }
            dicIst.setResultSet(attachedResultSet);
            Set<CrossZon> attachedCrossZonSet = new HashSet<CrossZon>();
            for (CrossZon crossZonSetCrossZonToAttach : dicIst.getCrossZonSet()) {
                crossZonSetCrossZonToAttach = em.getReference(crossZonSetCrossZonToAttach.getClass(), crossZonSetCrossZonToAttach.getCrossZonPK());
                attachedCrossZonSet.add(crossZonSetCrossZonToAttach);
            }
            dicIst.setCrossZonSet(attachedCrossZonSet);
            em.persist(dicIst);
            for (Result resultSetResult : dicIst.getResultSet()) {
                DicIst oldDicIstOfResultSetResult = resultSetResult.getDicIst();
                resultSetResult.setDicIst(dicIst);
                resultSetResult = em.merge(resultSetResult);
                if (oldDicIstOfResultSetResult != null) {
                    oldDicIstOfResultSetResult.getResultSet().remove(resultSetResult);
                    oldDicIstOfResultSetResult = em.merge(oldDicIstOfResultSetResult);
                }
            }
            for (CrossZon crossZonSetCrossZon : dicIst.getCrossZonSet()) {
                DicIst oldDicIstOfCrossZonSetCrossZon = crossZonSetCrossZon.getDicIst();
                crossZonSetCrossZon.setDicIst(dicIst);
                crossZonSetCrossZon = em.merge(crossZonSetCrossZon);
                if (oldDicIstOfCrossZonSetCrossZon != null) {
                    oldDicIstOfCrossZonSetCrossZon.getCrossZonSet().remove(crossZonSetCrossZon);
                    oldDicIstOfCrossZonSetCrossZon = em.merge(oldDicIstOfCrossZonSetCrossZon);
                }
            }
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(DicIst dicIst) throws NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            DicIst persistentDicIst = em.find(DicIst.class, dicIst.getIdIst());
            Set<Result> resultSetOld = persistentDicIst.getResultSet();
            Set<Result> resultSetNew = dicIst.getResultSet();
            Set<CrossZon> crossZonSetOld = persistentDicIst.getCrossZonSet();
            Set<CrossZon> crossZonSetNew = dicIst.getCrossZonSet();
            Set<Result> attachedResultSetNew = new HashSet<Result>();
            for (Result resultSetNewResultToAttach : resultSetNew) {
                resultSetNewResultToAttach = em.getReference(resultSetNewResultToAttach.getClass(), resultSetNewResultToAttach.getIdRezult());
                attachedResultSetNew.add(resultSetNewResultToAttach);
            }
            resultSetNew = attachedResultSetNew;
            dicIst.setResultSet(resultSetNew);
            Set<CrossZon> attachedCrossZonSetNew = new HashSet<CrossZon>();
            for (CrossZon crossZonSetNewCrossZonToAttach : crossZonSetNew) {
                crossZonSetNewCrossZonToAttach = em.getReference(crossZonSetNewCrossZonToAttach.getClass(), crossZonSetNewCrossZonToAttach.getCrossZonPK());
                attachedCrossZonSetNew.add(crossZonSetNewCrossZonToAttach);
            }
            crossZonSetNew = attachedCrossZonSetNew;
            dicIst.setCrossZonSet(crossZonSetNew);
            dicIst = em.merge(dicIst);
            for (Result resultSetOldResult : resultSetOld) {
                if (!resultSetNew.contains(resultSetOldResult)) {
                    resultSetOldResult.setDicIst(null);
                    resultSetOldResult = em.merge(resultSetOldResult);
                }
            }
            for (Result resultSetNewResult : resultSetNew) {
                if (!resultSetOld.contains(resultSetNewResult)) {
                    DicIst oldDicIstOfResultSetNewResult = resultSetNewResult.getDicIst();
                    resultSetNewResult.setDicIst(dicIst);
                    resultSetNewResult = em.merge(resultSetNewResult);
                    if (oldDicIstOfResultSetNewResult != null && !oldDicIstOfResultSetNewResult.equals(dicIst)) {
                        oldDicIstOfResultSetNewResult.getResultSet().remove(resultSetNewResult);
                        oldDicIstOfResultSetNewResult = em.merge(oldDicIstOfResultSetNewResult);
                    }
                }
            }
            for (CrossZon crossZonSetOldCrossZon : crossZonSetOld) {
                if (!crossZonSetNew.contains(crossZonSetOldCrossZon)) {
                    crossZonSetOldCrossZon.setDicIst(null);
                    crossZonSetOldCrossZon = em.merge(crossZonSetOldCrossZon);
                }
            }
            for (CrossZon crossZonSetNewCrossZon : crossZonSetNew) {
                if (!crossZonSetOld.contains(crossZonSetNewCrossZon)) {
                    DicIst oldDicIstOfCrossZonSetNewCrossZon = crossZonSetNewCrossZon.getDicIst();
                    crossZonSetNewCrossZon.setDicIst(dicIst);
                    crossZonSetNewCrossZon = em.merge(crossZonSetNewCrossZon);
                    if (oldDicIstOfCrossZonSetNewCrossZon != null && !oldDicIstOfCrossZonSetNewCrossZon.equals(dicIst)) {
                        oldDicIstOfCrossZonSetNewCrossZon.getCrossZonSet().remove(crossZonSetNewCrossZon);
                        oldDicIstOfCrossZonSetNewCrossZon = em.merge(oldDicIstOfCrossZonSetNewCrossZon);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = dicIst.getIdIst();
                if (findDicIst(id) == null) {
                    throw new NonexistentEntityException("The dicIst with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            DicIst dicIst;
            try {
                dicIst = em.getReference(DicIst.class, id);
                dicIst.getIdIst();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The dicIst with id " + id + " no longer exists.", enfe);
            }
            Set<Result> resultSet = dicIst.getResultSet();
            for (Result resultSetResult : resultSet) {
                resultSetResult.setDicIst(null);
                resultSetResult = em.merge(resultSetResult);
            }
            Set<CrossZon> crossZonSet = dicIst.getCrossZonSet();
            for (CrossZon crossZonSetCrossZon : crossZonSet) {
                crossZonSetCrossZon.setDicIst(null);
                crossZonSetCrossZon = em.merge(crossZonSetCrossZon);
            }
            em.remove(dicIst);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<DicIst> findDicIstEntities() {
        return findDicIstEntities(true, -1, -1);
    }

    public List<DicIst> findDicIstEntities(int maxResults, int firstResult) {
        return findDicIstEntities(false, maxResults, firstResult);
    }

    private List<DicIst> findDicIstEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(DicIst.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public DicIst findDicIst(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(DicIst.class, id);
        } finally {
            em.close();
        }
    }

    public int getDicIstCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<DicIst> rt = cq.from(DicIst.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }

}
